<possibleDataStructures>

	A node has multiple lists of node and multiple lists of float.
	Should it also have constant size list of int vars, or are sizes of the node lists enough?
	It must allow the same node list size to be used multiple times and in different ways.
	For example, size X could be used in X*2^X and X^Y in the same node.
	
	Should every int var have to be the same size as a node list?
	If list is size X, the duplicate vars could be named X0, X1, X2...
	
	How can temporary vars for iteration be defined?
	For example, for each combination of 3 nodes X0 X1 and X2 in X, do something...
	X0 X1 and X2 would be different nodes each iteration.
	
	Should lists in a node be visible outside a node?
	It may be faster for the node to take a float array as a parameter and iterate in it,
	but that prevents it from using any lists of the child nodes, which is needed in a neural net.
	
	Example: neuralNode(
		thisNodesValueForSortingInNetwork(1 number)
		thisNodesActivationLevel(1 number) //could combine this with thisNodesValueForSortingInNetwork
		childNodes(...)
		weightsOfChilds(...) //same size as childNodes
		temporaryVars(...) //to calculate weights average etc
	)
	
	Example: intentionallyTooComplexBayesLikeNode(
		thisNodesValueForSortingInNetwork(1 number)
		thisNodesChanceAccuracyWant(.5 .1 .8) //same size as chanceAccuracyWant
		chanceAccuracyWant(nodeChance nodeAccuracyOfChance nodeWantAccuracyOfChance) //immutable list
		bayesTruthConstants(bayesFalseNode bayesTrueNode) //immutable list
		childNodes(...)
		//could change (childNodes.size+1) to childNodes.size if childNodes includes this node
		floats(...) //size chanceAccuracyWant.size * bayesTruthConstants.size^(childNodes.size+1) //+1?
		shorterFloatList(...) //size bayesTruthConstants.size * childNodes.size
	)
	
	In intentionallyTooComplexBayesLikeNode above, how would floats.size be specified at runtime
	as a combination of 3 node lists sizes? How are multiply* and power^ specified at runtime?
	
	A string could easily specify that, but is it efficient enough?
	String example "node*(chanceAccuracyWant node^(bayesTruthConstants childNodes))"
	When compiled to a CS-like object, that string should be efficient enough.
	It specifies size of floats list easily, but how can it be efficient for iteration?
	The CS-like object could return another object which iterates, and in each iteration,
	writes to a constant-size float array and reads from it to put back into the nodes floats array(s).
	
	How should floats.size="node*(chanceAccuracyWant node^(bayesTruthConstants childNodes))"
	be combined with shorterFloatList.size="bayesTruthConstants * childNodes"?
	Confusing...
	"node*( childNodes node*(chanceAccuracyWant node^(bayesTruthConstants childNodes)) )"
	
	Lets simplify it and solve that problem later. Solve this first...
	"node*( childNodes node^(bayesTruthConstants childNodes) )"
	double d[] = new double[?];
	pow = (int) bayesTruthConstants power childNodes;
	for(nodeX in childNodes){
		for(p from 0 to pow-1){
			...todo write the pseudocode here...
		}
	}
	
	Lets try something easier. The problem is node lists can be used any number of times,
	and current thinking makes them all be used exactly once.
	It should be this form: codeTreeFrom --> codeTreeTo, where each part of codeTreeFrom points to some part of codeTreeTo, and all parts of codeTreeTo are pointed to at least once, but some parts of codeTreeFrom may not point to anything.
	
	Can it handle this one?:
	"node^(bayesTruthConstants1 childNodes1)" --> "node*(bayesTruthConstants0 childNodes0)"
	Maybe write it this way?:
	"node*( node*(bayesTruthConstants0 childNodes0) node^(bayesTruthConstants1 childNodes1) )"
	--> "node*(bayesTruthConstants0 childNodes0)"

	Example:
	"node*( node*(bayesTruthConstants0 childNodes0) node^(bayesTruthConstants1 childNodes1) )"
	--> "node*(bayesTruthConstants0 childNodes0)"
	But that does not specify that bayesTruthConstants does not increase the iteration size.
	For example, 2*5 * 2^5 has 5 * 2^5 iterations and 2*5 output size
	That could be written without the arrow -->, like this:
	"node*( node*(bayesTruthConstants_inonly childNodes_inandout) node^(bayesTruthConstants_inonly childNodes_inonly) )"
	
	Example: "node*(x node^(y x))" --> "node*(x y)"
	
	Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize
	
	Find counterexample where output sets contain anything that input sets do not.{
		If found, change:
		Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize
		
		Example: "neuralWeights" --> "1" //sums neural weights
		Fix example: "1 + neuralWeights" --> "1"
		
		If part of an output is not in the input, can it be trivially added?

	}

	Find example where input sets are smaller than iterationSize.{
		If that exists, use this theory instead:
		Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize

		If iterationSize is X times bigger than [inputs sets and sizes], multiply inputs by X.
	}
	
	
	Simple data structure that requires allocate new array every time change size:
	Node is Object[].
	Floats are double[].
	List of child nodes is Object[].
	Function is specific Java type, like AudivolvFunc,
		which takes a double[] parameter of constant size and reads and writes in it.
		How should size of AudivolvFunc be specified?
		Should input and output sizes in combinations be specified if asked?
		public interface AudivolvFunc{
			public void run(Object param);
			//public void run(Object param, Callback cb);
		}
	
	Other classes that may be useful to create, but may not be necessary:
		public interface Callback{
			/** the currently running AudivolvFunc should stop as soon as it knows this is true */
			public boolean requestedStop();
		}
	
	
</possibleDataStructures>